package com.dq.mybatis.core;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DBHelper {
	private Map<String,String> dataSourceMap;
	public DBHelper(Map<String,String> dataSourceMap) {
		this.dataSourceMap = dataSourceMap;
		try {
			Class. forName(dataSourceMap.get("driver"));
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	static{

	}

	/*获取连相的方法
	 *@return适回获取费的连格
	 */
	public Connection getConnection() {
		Connection con = null;
		try {
			con = DriverManager.getConnection(dataSourceMap.get("url"), dataSourceMap.get("username"), dataSourceMap.get("password"));
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		}
		return con;
	}

	/**
	 * 给预编译执行语句块中的占位符赋值
	 * @param pstmt 要赋值的预编译语句对象
	 * @param params 要赋的值
	 */
	public void setParams(PreparedStatement pstmt, Object ... params) {
		if (params != null && params.length > 0) { // 说明sql语句中有占位符
			// 给预编译执行语句中的占位符赋值
			for (int i = 0, len = params.length; i < len; i++) {
				try {
					pstmt.setObject(i+1, params[i]);
				} catch (SQLException e) {
					LogUtil.log.error("第 " + (i+1) +" 个参数注值失败...");
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 给预编译执行语句块中的占位符赋值
	 * @param pstmt 要赋值的预编译语句对象
	 * @param params 要赋的值
	 */
	public void setParams(PreparedStatement pstmt, List<Object> params) {
		if (params != null && params.size() > 0) { // 说明sql语句中有占位符
			// 给预编译执行语句中的占位符赋值
			for (int i = 0, len = params.size(); i < len; i++) {
				try {
					pstmt.setObject(i+1, params.get(i));
				} catch (SQLException e) {
					LogUtil.log.error("第 " + (i+1) +" 个参数注值失败...");
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 关闭资源的方法
	 * @param con 要关闭的连接
	 * @param pstmt 要关闭的预编译执行语句块
	 * @param rs 要关闭的结果集
	 */
	public void close(Connection con, PreparedStatement pstmt, ResultSet rs) {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				LogUtil.log.error(e);
				e.printStackTrace();
			}
		}

		if (pstmt != null) {
			try {
				pstmt.close();
			} catch (SQLException e) {
				LogUtil.log.error(e);
				e.printStackTrace();
			}
		}

		if (con != null) {
			try {
				con.close();
			} catch (SQLException e) {
				LogUtil.log.error(e);
				e.printStackTrace();
			}
		}
	}


	/**
	 * 更新操作
	 * @param sql 要执行的更新语句
	 * @param params 要执行的更新语句中占位符?对应的值
	 * @return
	 */
	public int update(String sql, List<Object> params){
		Connection con = null;
		PreparedStatement pstmt = null;

		try {
			con = this.getConnection(); // 获取连接
			pstmt = con.prepareStatement(sql); // 预编译执行语句
			this.setParams(pstmt, params);
			// 执行语句获取结果
			return pstmt.executeUpdate();
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, null);
		}
		return 0;
	}

	/**
	 * 更新操作
	 * @param sql 要执行的更新语句
	 * @param params 要执行的更新语句中占位符?对应的值
	 * @return
	 */
	public int update(String sql, Object ... params){
		Connection con = null;
		PreparedStatement pstmt = null;

		try {
			con = this.getConnection(); // 获取连接
			pstmt = con.prepareStatement(sql); // 预编译执行语句
			this.setParams(pstmt, params); // 给预编译执行语句中的占位符赋值
			// 执行语句获取结果
			return pstmt.executeUpdate();
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, null);
		}
		return 0;
	}

	/**
	 * 查询
	 * @param sql 要执行的查询语句
	 * @param params 查询语句中占位符?的值
	 * @return 所有满足条件的数据
	 */
	public List<Map<String, Object>> finds(String sql, Object ... params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;

		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();

		try {
			con = this.getConnection(); // 获取连接
			pstmt = con.prepareStatement(sql); // 预编译执行语句

			// 给预编译执行语句中的占位符赋值
			this.setParams(pstmt, params);

			rs = pstmt.executeQuery();

			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			// 循环获取结果集中每个列的类名
			for (int i=1; i<=colCount; i++) {
				colNames[i-1] = rsmd.getColumnName(i).toLowerCase();
			}
			// 每次while得到的是一行记录，每一行记录存放到一个list中
			Map<String, Object> map = null;
			while(rs.next()) { // 取值方式两种：一种是根据列名(获取结果集中返回的所有的列的列名)、一种是根据索引(获取结果集中列的数量)
				map = new HashMap<String, Object>();
				for (String colName: colNames) { // 每循环一次得到的是一个列的值
					map.put(colName, rs.getObject(colName));
				}
				// 当循环结束，说明这一行记录已经读完，那么我们将这一行记录存放到list中
				list.add(map);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return list;
	}

	/**
	 * 查询
	 * @param sql 要执行的查询语句
	 * @param params 查询语句中占位符?的值
	 * @return 所有满足条件的数据
	 */
	public List<Map<String, Object>> finds(String sql, List<Object> params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;

		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();

		try {
			con = this.getConnection(); // 获取连接
			pstmt = con.prepareStatement(sql); // 预编译执行语句

			// 给预编译执行语句中的占位符赋值
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();

			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			// 循环获取结果集中每个列的类名
			for (int i=1; i<=colCount; i++) {
				colNames[i-1] = rsmd.getColumnName(i).toLowerCase();
			}
			// 每次while得到的是一行记录，每一行记录存放到一个list中
			Map<String, Object> map = null;
			while(rs.next()) { // 取值方式两种：一种是根据列名(获取结果集中返回的所有的列的列名)、一种是根据索引(获取结果集中列的数量)
				map = new HashMap<String, Object>();
				for (String colName: colNames) { // 每循环一次得到的是一个列的值
					map.put(colName, rs.getObject(colName));
				}
				// 当循环结束，说明这一行记录已经读完，那么我们将这一行记录存放到list中
				list.add(map);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return list;
	}

	/**
	 * 查询
	 * @param sql 要执行的查询语句
	 * @param params 查询语句中占位符?的值
	 * @return 所有满足条件的数据
	 */
	public List<Map<String, String>> findStr(String sql, Object ... params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;

		List<Map<String, String>> list = new ArrayList<Map<String, String>>();

		try {
			con = this.getConnection(); // 获取连接
			pstmt = con.prepareStatement(sql); // 预编译执行语句

			// 给预编译执行语句中的占位符赋值
			this.setParams(pstmt, params);

			rs = pstmt.executeQuery();

			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			// 循环获取结果集中每个列的类名
			for (int i=1; i<=colCount; i++) {
				colNames[i-1] = rsmd.getColumnName(i).toLowerCase();
			}
			// 每次while得到的是一行记录，每一行记录存放到一个list中
			Map<String, String> map = null;
			while(rs.next()) { // 取值方式两种：一种是根据列名(获取结果集中返回的所有的列的列名)、一种是根据索引(获取结果集中列的数量)
				map = new HashMap<String, String>();
				for (String colName: colNames) { // 每循环一次得到的是一个列的值
					map.put(colName, rs.getString(colName));
				}
				// 当循环结束，说明这一行记录已经读完，那么我们将这一行记录存放到list中
				list.add(map);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return list;
	}

	/**
	 * 查询
	 * @param sql 要执行的查询语句
	 * @param params 查询语句中占位符?的值
	 * @return 所有满足条件的数据
	 */
	public List<Map<String, String>> findStr(String sql, List<Object> params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;

		List<Map<String, String>> list = new ArrayList<Map<String, String>>();

		try {
			con = this.getConnection(); // 获取连接
			pstmt = con.prepareStatement(sql); // 预编译执行语句

			// 给预编译执行语句中的占位符赋值
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();

			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			// 循环获取结果集中每个列的类名
			for (int i=1; i<=colCount; i++) {
				colNames[i-1] = rsmd.getColumnName(i).toLowerCase();
			}
			// 每次while得到的是一行记录，每一行记录存放到一个list中
			Map<String, String> map = null;
			while(rs.next()) { // 取值方式两种：一种是根据列名(获取结果集中返回的所有的列的列名)、一种是根据索引(获取结果集中列的数量)
				map = new HashMap<String, String>();
				for (String colName: colNames) { // 每循环一次得到的是一个列的值
					map.put(colName, rs.getString(colName));
				}
				// 当循环结束，说明这一行记录已经读完，那么我们将这一行记录存放到list中
				list.add(map);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return list;
	}

	/**
	 * 获取总记录数的方法
	 * @param sql
	 * @param params
	 * @return
	 */
	public int getTotal(String sql, Object ... params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;

		try {
			con = this.getConnection();
			pstmt = con.prepareStatement(sql);
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();
			if (rs.next()) {
				return rs.getInt(1);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return 0;
	}

	/**
	 * 获取总记录数的方法
	 * @param sql
	 * @param params
	 * @return
	 */
	public int getTotal(String sql, List<Object> params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;

		try {
			con = this.getConnection();
			pstmt = con.prepareStatement(sql);
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();
			if (rs.next()) {
				return rs.getInt(1);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return 0;
	}

	/**
	 * 基于对象的查询
	 * @param sql
	 * @param cl
	 * @param params
	 * @return
	 */
	public <T> List<T> findObject(String sql, Class<T> cl, Object ... params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		List<T> list = new ArrayList<T>();

		try {
			con = this.getConnection();
			pstmt = con.prepareStatement(sql);
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();

			// 每循环一次就是一个对象 -> 实例化一个对象出来  -> 给这个对象中对应的属性赋值 -> 要获取这个对象中的所有setter方法 -> 如何判断哪个值要调用哪个setter方法
			// 规定： 属性名必须跟列名相同（如果建表的时候属性名跟列名不相同，则在查询的时候必须重命名列） -> 在列名前面+set然后跟setter方法去对比  -> 获取这个结果集中所有列的列名

			// 获取结果集中所有列的列名
			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			for (int i=0; i<colCount; i++) {
				colNames[i] = rsmd.getColumnName(i+1);
			}

			// 获取给定类中的所有方法 -> setter方法
			Method[] methods = cl.getDeclaredMethods();
			List<Method> setters = new ArrayList<Method>();
			for (Method md : methods) {
				if (md.getName().startsWith("set")) {
					setters.add(md);
				}
			}

			T t = null;
			String mname = null;
			Class<?>[] types = null;
			String typeName = null;

			while(rs.next()) { 
				t = cl.newInstance(); // 每循环一次创建一个对象

				// 将对应列中的值注入到这个对象对应的属性中
				for (String colName : colNames) { // 循环所有的列名
					mname = "set" + colName;      // deptno  ->  setdeptno
					for (Method md : setters) { // 循环所有的方法      setDeptno()
						if (mname.equalsIgnoreCase(md.getName())) { // 说明这个列的值应该要调用这个方法注入
							// 获取一个setter方法的形参类型
							types = md.getParameterTypes();

							// 判断这个方法有没有形参
							if (types != null && types.length > 0) { // 取出第一个形参类型的类型名
								typeName = types[0].getSimpleName();
								if ("int".equals(typeName) || "Integer".equals(typeName)) {
									md.invoke(t, rs.getInt(colName)); // 反向激活这个方法   第一个参数是：哪个对象的这个方法  第二个参数是这个方法的形参
								} else if ("float".equals(typeName) || "Float".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else if ("double".equals(typeName) || "Double".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else {
									md.invoke(t, rs.getString(colName));
								}
							}

							break;
						}
					}
				}
				list.add(t);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InstantiationException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return list;
	}


	/**
	 * 基于对象的查询
	 * @param sql
	 * @param cl
	 * @param params
	 * @return
	 */
	public <T> List<T> findObject(String sql, Class<T> cl, List<Object> params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		List<T> list = new ArrayList<T>();

		try {
			con = this.getConnection();
			pstmt = con.prepareStatement(sql);
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();

			// 每循环一次就是一个对象 -> 实例化一个对象出来  -> 给这个对象中对应的属性赋值 -> 要获取这个对象中的所有setter方法 -> 如何判断哪个值要调用哪个setter方法
			// 规定： 属性名必须跟列名相同（如果建表的时候属性名跟列名不相同，则在查询的时候必须重命名列） -> 在列名前面+set然后跟setter方法去对比  -> 获取这个结果集中所有列的列名

			// 获取结果集中所有列的列名
			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			for (int i=0; i<colCount; i++) {
				colNames[i] = rsmd.getColumnName(i+1);
			}

			// 获取给定类中的所有方法 -> setter方法
			Method[] methods = cl.getDeclaredMethods();
			List<Method> setters = new ArrayList<Method>();
			for (Method md : methods) {
				if (md.getName().startsWith("set")) {
					setters.add(md);
				}
			}

			T t = null;
			String mname = null;
			Class<?>[] types = null;
			String typeName = null;

			while(rs.next()) { 
				t = cl.newInstance(); // 每循环一次创建一个对象

				// 将对应列中的值注入到这个对象对应的属性中
				for (String colName : colNames) { // 循环所有的列名
					mname = "set" + colName;      // deptno  ->  setdeptno
					for (Method md : setters) { // 循环所有的方法      setDeptno()
						if (mname.equalsIgnoreCase(md.getName())) { // 说明这个列的值应该要调用这个方法注入
							// 获取一个setter方法的形参类型
							types = md.getParameterTypes();

							// 判断这个方法有没有形参
							if (types != null && types.length > 0) { // 取出第一个形参类型的类型名
								typeName = types[0].getSimpleName();
								if ("int".equals(typeName) || "Integer".equals(typeName)) {
									md.invoke(t, rs.getInt(colName)); // 反向激活这个方法   第一个参数是：哪个对象的这个方法  第二个参数是这个方法的形参
								} else if ("float".equals(typeName) || "Float".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else if ("double".equals(typeName) || "Double".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else {
									md.invoke(t, rs.getString(colName));
								}
							}

							break;
						}
					}
				}
				list.add(t);
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InstantiationException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return list;
	}

	/**
	 * 基于对象的查询
	 * @param sql
	 * @param cl
	 * @param params
	 * @return
	 */
	public <T> T findSingleObject(String sql, Class<T> cl, Object ... params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		T t = null;
		try {
			con = this.getConnection();
			pstmt = con.prepareStatement(sql);
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();

			// 每循环一次就是一个对象 -> 实例化一个对象出来  -> 给这个对象中对应的属性赋值 -> 要获取这个对象中的所有setter方法 -> 如何判断哪个值要调用哪个setter方法
			// 规定： 属性名必须跟列名相同（如果建表的时候属性名跟列名不相同，则在查询的时候必须重命名列） -> 在列名前面+set然后跟setter方法去对比  -> 获取这个结果集中所有列的列名

			// 获取结果集中所有列的列名
			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			for (int i=0; i<colCount; i++) {
				colNames[i] = rsmd.getColumnName(i+1);
			}

			// 获取给定类中的所有方法 -> setter方法
			Method[] methods = cl.getDeclaredMethods();
			List<Method> setters = new ArrayList<Method>();
			for (Method md : methods) {
				if (md.getName().startsWith("set")) {
					setters.add(md);
				}
			}

			String mname = null;
			Class<?>[] types = null;
			String typeName = null;

			if(rs.next()) { 
				t = cl.newInstance(); // 每循环一次创建一个对象

				// 将对应列中的值注入到这个对象对应的属性中
				for (String colName : colNames) { // 循环所有的列名
					mname = "set" + colName;      // deptno  ->  setdeptno
					for (Method md : setters) { // 循环所有的方法      setDeptno()
						if (mname.equalsIgnoreCase(md.getName())) { // 说明这个列的值应该要调用这个方法注入
							// 获取一个setter方法的形参类型
							types = md.getParameterTypes();

							// 判断这个方法有没有形参
							if (types != null && types.length > 0) { // 取出第一个形参类型的类型名
								typeName = types[0].getSimpleName();
								if ("int".equals(typeName) || "Integer".equals(typeName)) {
									md.invoke(t, rs.getInt(colName)); // 反向激活这个方法   第一个参数是：哪个对象的这个方法  第二个参数是这个方法的形参
								} else if ("float".equals(typeName) || "Float".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else if ("double".equals(typeName) || "Double".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else {
									md.invoke(t, rs.getString(colName));
								}
							}

							break;
						}
					}
				}
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InstantiationException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return t;
	}


	/**
	 * 基于对象的查询
	 * @param sql
	 * @param cl
	 * @param params
	 * @return
	 */
	public <T> T findSingleObject(String sql, Class<T> cl, List<Object> params) {
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		T t = null;
		try {
			con = this.getConnection();
			pstmt = con.prepareStatement(sql);
			this.setParams(pstmt, params);
			rs = pstmt.executeQuery();

			// 每循环一次就是一个对象 -> 实例化一个对象出来  -> 给这个对象中对应的属性赋值 -> 要获取这个对象中的所有setter方法 -> 如何判断哪个值要调用哪个setter方法
			// 规定： 属性名必须跟列名相同（如果建表的时候属性名跟列名不相同，则在查询的时候必须重命名列） -> 在列名前面+set然后跟setter方法去对比  -> 获取这个结果集中所有列的列名

			// 获取结果集中所有列的列名
			ResultSetMetaData rsmd = rs.getMetaData();
			int colCount = rsmd.getColumnCount();
			String[] colNames = new String[colCount];
			for (int i=0; i<colCount; i++) {
				colNames[i] = rsmd.getColumnName(i+1);
			}

			// 获取给定类中的所有方法 -> setter方法
			Method[] methods = cl.getDeclaredMethods();
			List<Method> setters = new ArrayList<Method>();
			for (Method md : methods) {
				if (md.getName().startsWith("set")) {
					setters.add(md);
				}
			}

			String mname = null;
			Class<?>[] types = null;
			String typeName = null;

			if(rs.next()) { 
				t = cl.newInstance(); // 每循环一次创建一个对象

				// 将对应列中的值注入到这个对象对应的属性中
				for (String colName : colNames) { // 循环所有的列名
					mname = "set" + colName;      // deptno  ->  setdeptno
					for (Method md : setters) { // 循环所有的方法      setDeptno()
						if (mname.equalsIgnoreCase(md.getName())) { // 说明这个列的值应该要调用这个方法注入
							// 获取一个setter方法的形参类型
							types = md.getParameterTypes();

							// 判断这个方法有没有形参
							if (types != null && types.length > 0) { // 取出第一个形参类型的类型名
								typeName = types[0].getSimpleName();
								if ("int".equals(typeName) || "Integer".equals(typeName)) {
									md.invoke(t, rs.getInt(colName)); // 反向激活这个方法   第一个参数是：哪个对象的这个方法  第二个参数是这个方法的形参
								} else if ("float".equals(typeName) || "Float".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else if ("double".equals(typeName) || "Double".equals(typeName)) {
									md.invoke(t, rs.getFloat(colName));
								} else {
									md.invoke(t, rs.getString(colName));
								}
							}

							break;
						}
					}
				}
			}
		} catch (SQLException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InstantiationException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			LogUtil.log.error(e);
			e.printStackTrace();
		} finally {
			this.close(con, pstmt, rs);
		}
		return t;
	}
}
